home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / rs232.exe / RS232.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-03  |  43.6 KB  |  1,284 lines
  1. /* rs232.h v1.5 */
  2.  
  3. /* port characteristic definitions for use with rs_initport */
  4.    /* port id's */
  5. #define RS_PORT1 '1'       /* port 1 */
  6. #define RS_PORT2 '2'       /*   .    */
  7. #define RS_PORT3 '3'       /*   .    */
  8. #define RS_PORT4 '4'       /* port 4 */
  9.    /* baud rates */
  10. #define RS_B110 110L       /* 110 baud */
  11. #define RS_B300 300L       /*    .     */
  12. #define RS_B600 600L       /*    .     */
  13. #define RS_B1200 1200L     /*    .     */
  14. #define RS_B2400 2400L     /*    .     */
  15. #define RS_B4800 4800L     /*    .     */
  16. #define RS_B9600 9600L     /*    .     */
  17. #define RS_B19K 19200L     /*    .     */
  18. #define RS_B38K 38400L     /*    .     */
  19. #define RS_B57K 57600L     /*    .     */
  20. #define RS_B115K 115200L   /* 115200 baud */
  21.    /* parity */
  22. #define RS_NOPAR 'N'       /* no parity */
  23. #define RS_EVPAR 'E'       /* even parity */
  24. #define RS_ODPAR 'O'       /* odd parity */
  25. #define RS_SPPAR 'S'       /* space parity */
  26. #define RS_MKPAR 'M'       /* mark parity */
  27.    /* data bits */
  28. #define RS_DBIT8 '8'       /* 8 data bits */
  29. #define RS_DBIT7 '7'       /* 7 data bits */
  30.    /* stop bits */
  31. #define RS_SBIT1 '1'       /* 1 stop bit */
  32. #define RS_SBIT2 '2'       /* 2 stop bits */
  33. /* values returned by rs_initport */
  34. #define RS_UART4 4         /* init. OK, UART is 16550AF,C,CF */
  35. #define RS_UART3 3         /* init. OK, UART is 16550 */
  36. #define RS_UART2 2         /* init. OK, UART is 8250A or 16450 */
  37. #define RS_UART1 1         /* init. OK, UART is 8250 or 8250B */
  38. #define RS_NOUART 0        /* init. failed - no UART detected */
  39. #define RS_BADIBUF -1      /* init. failed - in. buffer or size bad */
  40. #define RS_BADOBUF -2      /* init. failed - out. buffer or size bad */
  41. #define RS_BADPORT -3      /* init. failed - invalid port argument */
  42. #define RS_BADPAR -4       /* init. failed - invalid parity argument */
  43. #define RS_BADDBIT -5      /* init. failed - invalid data bits argument */
  44. #define RS_BADSBIT -6      /* init. failed - invalid stop bits argument */
  45. #define RS_BADBAUD -7      /* init. failed - invalid baud argument */
  46.  
  47. /* bit definitions to test value returned by rs_error */
  48. #define RS_RBER 0x01       /* Receive data overrun (receive buffer) */
  49. #define RS_ROER 0x02       /* Receive data overrun (UART) */
  50. #define RS_PERR 0x04       /* Parity error */
  51. #define RS_FERR 0x08       /* Framing error */
  52. #define RS_BKDT 0x10       /* Break detected */
  53. #define RS_FFER 0x80       /* Error in receive FIFO */
  54.  
  55. /* definitions for use with rs_modctrl */
  56. #define RS_GETMSR 0 /* command to read state of modem status lines */
  57.   /* bit definitions to test value returned with RS_GETMSR cmd */
  58.   #define RS_CTSCHG 0x01   /* CTS changed states */
  59.   #define RS_DSRCHG 0x02   /* DSR changed states */
  60.   #define RS_RICHG  0x04   /* RI changed states */
  61.   #define RS_DCDCHG 0x08   /* DCD changed states */
  62.   #define RS_CTSSTE 0x10   /* state of CTS */
  63.   #define RS_DSRSTE 0x20   /* state of DSR */
  64.   #define RS_RISTE  0x40   /* state of RI */
  65.   #define RS_DCDSTE 0x80   /* state of DCD */
  66. #define RS_WRTMCR 1 /* command to control hardware control lines */
  67.   /* parameter1 definitions for use with RS_WRTMCR and RS_GETMCR commands */
  68.   #define RS_MCRDTR 1      /* DTR line */
  69.   #define RS_MCRRTS 2      /* RTS line */
  70.   /* parameter2 definitions for use with RS_WRTMCR command */
  71.   #define RS_LINON 1       /* turn selected line on */
  72.   #define RS_LINOFF 0      /* turn selected line off */
  73. #define RS_GETMCR 2 /* command to return current state of modem control reg. */
  74.  
  75. /* command definitions for rs_timer */
  76. #define RS_CLRTIM 0 /* return timer count, set timer to 0 */
  77. #define RS_GETTIM 1 /* return timer count, do not clear */
  78.  
  79. /* definitions for rs_setflow */
  80. #define RS_FLWOFF 0 /* command to turn flow control off */
  81. #define RS_FLWHDW 1 /* command to turn hardware flow control on */
  82.   /* parameter1 bit definitions for use with RS_FLWHDW command */
  83.   #define RS_FLWCTS 1      /* use CTS line */
  84.   #define RS_FLWDSR 2      /* use DSR line */
  85.   #define RS_FLWRI  4      /* use RI line */
  86.   #define RS_FLWDCD 8      /* use DCD line */
  87. #define RS_FLWXON 2 /* command to turn XON/XOFF flow control on */
  88.   /* parameter1 and parameter2 definitions for use with RS_FLWXON */
  89.   #define RS_XON 0x11      /* standard XON character */
  90.   #define RS_XOFF 0x13     /* standard XOFF character */
  91. #define RS_FLWSTAT 3 /* command to return status of flow control */
  92.   /* values returned by RS_FLWSTAT command */
  93.   #define RS_FLWHLT 1      /* output halted by flow control */
  94.   #define RS_FLWNHLT 0     /* output not halted by flow control */
  95. #define RS_FLWINS 4 /* command to insert control byte in output stream */
  96.  
  97. /*****************************************************************/
  98. /***                   function prototypes                     ***/
  99. /*****************************************************************/
  100.      /* interrupt handler */
  101. void interrupt rs_inthndlr(void);
  102.  
  103.      /* port initialization: Sets up port parameters, installs interrupt
  104.         vector, enables interrupts.  Input and output buffers are 'rotary'
  105.         buffers - buffer size must be a power of 2.  Function returns the
  106.         following:
  107.           4 - Success, 16550 UART, FIFOs enabled.
  108.           3 - Success, 16550 UART, FIFOs unavailable.
  109.           2 - Success, 8250A or 16450 UART
  110.           1 - Success, 8250B UART
  111.           0 - Fail, no UART detected
  112.          -1 - Fail, bad input buffer
  113.          -2 - Fail, bad output buffer
  114.          -3 - Fail, bad port argument
  115.          -4 - Fail, bad parity argument
  116.          -5 - Fail, bad data bits argument
  117.          -6 - Fail, bad stop bits argument
  118.          -7 - Fail, bad baud argument
  119.         Example:
  120.       status = rs_initport(port,baud,parity,bits,stop,in_bufsize,in_bufptr,\
  121.                            out_bufsize,out_bufptr);
  122.       port = '1','2','3', or '4'
  123.       baud = 110, 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600 or 115200
  124.       parity = 'N', 'E', 'O', 'S' or 'M'
  125.       bits = '7' or '8'
  126.       stop = '1' or '2'
  127.       in_bufsize = (power of 2) >= 2 <= 32768
  128.       in_bufptr = char pointer to previously allocated input buffer
  129.       out_bufsize = (power of 2) >= 2 <= 32768
  130.       out_bufptr = char pointer to previously allocated output buffer */
  131. int rs_initport(char, long, char, char, char,
  132.                 unsigned, char *, unsigned, char *);
  133.  
  134.      /* Send single byte out port - if no room in output buffer, wait
  135.         til there's room.  Return 0 on success, or -1 if no room in
  136.         output buffer and output is currently disabled via flow control
  137.         or if port is unavailable.  If RS_POLLED_XMIT is defined, xmit buffer
  138.         and xmit interrupts are not used. */
  139. int rs_sndbyt(int);
  140.  
  141.      /* Send string of specified length out port - if no room in output
  142.         buffer, waits til there's room.  Return 0 on success or number of
  143.         bytes copied to output buffer if not enough room for entire string
  144.         and output is currently disabled via flow control.  Returns -1 if
  145.         port is not available.  If length is 0 (unspecified), send chars
  146.         from string up to but not including terminating nul character.
  147.         If RS_POLLED_XMIT is defined in header, xmit interrupts are not used
  148.         and the function does not return until the string has been sent. */
  149. int rs_sndstr(int,char *);
  150.  
  151.      /* Get single char, return -1 if none available or port is not
  152.         available. */
  153. int rs_getbyt(void);
  154.  
  155.      /* Get specified number of characters from input buffer.  If less
  156.         than the specified number of characters are available, get as
  157.         many as are available.  If length of string is unspecified (0),
  158.         copy characters up to and including terminating nul. Return number
  159.         of characters copied or -1 if port is unavailable.  Null terminate
  160.         string. */
  161. int rs_getstr(int, char *);
  162.  
  163.      /* Return number of characters waiting to be read from input buffer. */
  164. unsigned rs_inrcvd(void);
  165.  
  166.      /* Return amount of free space in output buffer. */
  167. unsigned rs_outfre(void);
  168.  
  169.      /* Return code for last error detected as follows:
  170.         bit 0: 1 = Receive overrun (buffer)
  171.         bit 1: 1 = Receive overrun (UART)
  172.         bit 2: 1 = Parity error
  173.         bit 3: 1 = Framing error
  174.         bit 4: 1 = Break detected
  175.         bit 7: 1 = Error in receive FIFO
  176.      Return 0 if no error since last call to rs_error()   */
  177. int rs_error(void);
  178.  
  179.      /* If rs_cmd = 0, return modem status as follows:
  180.           bit 0: CTS line changed state
  181.           bit 1: DTR line change state
  182.           bit 2: RI line changed state
  183.           bit 3: DCD line changed state
  184.           bit 4: current state of CTS line
  185.           bit 5: current state of DTR line
  186.           bit 6: current state of RI line
  187.           bit 7: current state of DCD line
  188.         Bits 0 - 3 will be 0 unless a status line has changed states since
  189.         the last call to rs_modctrl();
  190.         If rs_cmd = 1, parameter 1 is bit pattern for line to control.
  191.         Parameter2 = 0 turns line off, parameter 2 = 1 turns line on.
  192.         Returns -1 if port is unavailable. */
  193. int rs_modctrl(int rs_cmd,...);
  194.  
  195.      /* Send break to remote.  Return -1 if port is unavailable. */
  196. int rs_break(void);
  197.  
  198.      /* clear output buffer of any bytes not yet sent */
  199. void rs_clrout(void);
  200.  
  201.      /* clear input buffer of any bytes received but not yet read */
  202. void rs_clrin(void);
  203.  
  204.      /* return 0 if no keystrokes pending, 1 if key has been pressed */
  205. int rs_keyhit(void);
  206.  
  207.      /* If rs_cmd = 0, set timer to 0 and return 18.2Hz tick count since
  208.         timer was last zeroed or port was initialized.
  209.         If rs_cmd = 1, return current value of timer.*/
  210. unsigned rs_timer(int rs_cmd);
  211.  
  212.      /* Set flow control characteristics or check status
  213.                rs_cmd = 0: Turn flow control off
  214.                rs_cmd = 1: Set flow control to hardware.  Parameter1
  215.                            is hardware line to monitor.
  216.                rs_cmd = 2: Set flow control to XON/XOFF - Parameter1
  217.                            is character to use for XON, Parameter2
  218.                            is character to use for XOFF.
  219.                rs_cmd = 3: Return status of flow control - 0 = output
  220.                            normal, 1 = output halted
  221.                rs_cmd = 4: Insert control character in output stream.
  222.                            Parameter1 is control character.
  223.         Returns -1 if port is unavailable */
  224. int rs_setflow(int rs_cmd,...);
  225.  
  226.      /* Call this function before exiting program or when finished with port.
  227.         Restores interrupt vector and interrupt mask, and disables port
  228.         interrupts. */
  229. void rs_close(void);
  230.  
  231. /********************* Cut here for seperate header file *********************/
  232. /***
  233.  
  234.       RS232: Set of general purpose functions providing fully buffered
  235.       interrupt driven serial I/0.  Supports baud rates from 110 to
  236.       115.2K on serial ports 1 - 4.  Compiled and tested with Turbo C 2.0,
  237.       Turbo C++, Borland C++ 2.0, Borland C++ 3.1.
  238.  
  239.       3/5/92
  240.       v1.5
  241.       revised 10/12/92, 11/2/92, 12/13/92, 2/7/93, 5/2/93
  242.       copyrght. C. Karcher 1992,93
  243.       Seattle WA
  244.       CSID 76406,536
  245.  
  246.       11/2/92  Fixed rs_sndstr bug: sending string longer than buffer len.
  247.                Fixed rs_timer bug: when timer was cleared and then read
  248.                before it had a chance to increment past 0, 176 was returned.
  249.                Fixed bug in interrupt service routine which prevented rs_sndstr
  250.                from working with modem board which emulates 8250B UART.
  251.  
  252.       12/13/92 Corrected unterminated comment in rs_initport where defining
  253.                rs_ss.fcr.  Changed timer rollover constant type from L to UL
  254.                in rs_timer.
  255.  
  256.       1/9/93   Fixed bug in rs_initport where defining base address for ports
  257.                3 and 4 - IRQ number and interrupt mask was left unitialized
  258.                if BIOS data area showed no base address for port.
  259.  
  260.       2/7/93   Corrected bug in interrupt service routine which caused
  261.                receive FIFO to be read incorrectly.  Corrected bug in
  262.                rs_sndsr and rs_sndbyt preventing an xmit interrupt from
  263.                being generated.  Added preprocessor directives and code
  264.                to use polling method instead of interrupts for character
  265.                transmission if RS_POLLED_XMIT is defined.
  266.  
  267.       5/2/93   Added preprocessor directives in interrupt service routine
  268.                to prevent code generated by TC2.0 and earlier from trashing
  269.                incoming characters in large memory models.
  270.  
  271. ***/
  272.  
  273. #include<dos.h>        /* need dos.h for port i/o and interrupt funcs. */
  274. #include<stdarg.h>     /* for variable arguments in some functions */
  275.  
  276. #ifndef NULL
  277.   #if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
  278.     #define NULL    0
  279.   #else
  280.     #define NULL    0L
  281.   #endif
  282. #endif
  283.  
  284. unsigned rs_timer(int rs_cmd);
  285. void rs_close(void);
  286.  
  287. /*****************************************************************/
  288. /***          global variables - all names begin with rs_      ***/
  289. /*****************************************************************/
  290. struct rs_statics{                     /* static variables */
  291.   int int_no;
  292.   int flow;
  293.   int xmitfifo;
  294.   int thr;
  295.   int rbr;
  296.   int iir;
  297.   int fcr;
  298.   int ier;
  299.   int mcr;
  300.   int lsr;
  301.   int lcr;
  302.   int msr;
  303.   int uart;
  304.   unsigned ibuf_siz;
  305.   unsigned obuf_siz;
  306.   char xon;
  307.   char xoff;
  308.   char hdw_flw;
  309.   unsigned char *in_buf;
  310.   unsigned char *out_buf;
  311.   unsigned char oldmask;
  312.   }rs_ss;
  313.  
  314. volatile struct rs_dynamics{           /* dynamic variables */
  315.   unsigned in_head;
  316.   unsigned in_tail;
  317.   unsigned out_head;
  318.   unsigned out_tail;
  319.   unsigned rcv_cnt;
  320.   unsigned char ier_msk;
  321.   unsigned char msr_cod;
  322.   unsigned char err_cod;
  323.   }rs_ds;
  324.  
  325. int rs_portopen = 0;
  326. void interrupt (*rs_oldvec)(void) = NULL;
  327.  
  328. /* Interrupt service routine - Get received character from port rs_ss.rbr,
  329.    store in rs_ss.in_buf and increment rs_inrcv.  If flow control enabled,
  330.    update global variable rs_ss.iermsk to enable or disable output as
  331.    required */
  332. void interrupt rs_inthndlr(void)
  333. {
  334.  
  335.   extern struct rs_statics rs_ss;
  336.   extern volatile struct rs_dynamics rs_ds;
  337.   extern void interrupt (*rs_oldvec)(void);
  338.   int rs_xmitcnt;
  339.  
  340. #ifndef RS_POLLED_XMIT
  341.   if(rs_ss.uart)
  342.     outportb(rs_ss.ier,rs_ds.ier_msk);   /* nudge interrupt if not 8250B */
  343. #endif
  344.   _AL = (inportb(rs_ss.iir) & '\x07');   /* get interrupt id */
  345.   if(!(_AL & '\x01')){     /* interrupt pending ? */
  346.     do{
  347.       if(_AL == '\x06'){   /* receive error ? */
  348.         rs_ds.err_cod = inportb(rs_ss.lsr); /* record error */
  349.         }
  350.       else if((_AL & '\x04')){  /* data received interrupt ? */
  351.         do{
  352.           _AL = inportb(rs_ss.rbr); /* get the byte */
  353. #if defined(__TURBOC__) && (__TURBOC__ <= 0x0200)
  354.    #if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
  355.       _CL = _AL;
  356.    #endif
  357. #endif
  358.       if(rs_ss.flow == 2){
  359.         if(_AL == rs_ss.xon){
  360. #ifndef RS_POLLED_XMIT
  361.           outportb(rs_ss.ier,'\x0F');
  362. #endif
  363.           rs_ds.ier_msk = '\x0F';
  364.           }
  365.         else if(_AL == rs_ss.xoff){
  366. #ifndef RS_POLLED_XMIT
  367.           outportb(rs_ss.ier,'\x0D');
  368. #endif
  369.           rs_ds.ier_msk = '\x0D';
  370.           }
  371.         else
  372.           goto rs_J1;
  373.         }
  374.       else{
  375.         /* store incoming byte */
  376.       rs_J1:
  377. #if defined(__TURBOC__) && (__TURBOC__ <= 0x0200)
  378.   #if defined(__COMPACT__) || defined(__LARGE__) || defined(__HUGE__)
  379.         *(rs_ss.in_buf + rs_ds.in_head++) = _CL;
  380.   #else
  381.             *(rs_ss.in_buf + rs_ds.in_head++) = _AL;
  382.   #endif
  383. #else
  384.             *(rs_ss.in_buf + rs_ds.in_head++) = _AL;
  385. #endif
  386.             /* in case head ptr wrapped around */
  387.             rs_ds.in_head &= rs_ss.ibuf_siz;
  388.             rs_ds.rcv_cnt++; /* track rcv buffer overflow */
  389.             }
  390.           }while(inportb(rs_ss.lsr) & '\x01'); /* loop while data avail. */
  391.         }
  392. #ifndef RS_POLLED_XMIT
  393.       else if(_AL & '\x02'){    /* transmit holding reg. empty ? */
  394.         for(rs_xmitcnt = 0;rs_xmitcnt < rs_ss.xmitfifo;rs_xmitcnt++){
  395.           /* send a byte if any to send */
  396.           if(rs_ds.out_tail != rs_ds.out_head){
  397.             outportb(rs_ss.thr,*(rs_ss.out_buf + rs_ds.out_tail++));
  398.             /* in case tail pointer wrapped around */
  399.             rs_ds.out_tail &= rs_ss.obuf_siz;
  400.             }
  401.           else
  402.             break;
  403.           }
  404.         }
  405. #endif
  406.       else{ /* change in one of the modem control lines */
  407.         rs_ds.msr_cod = inportb(rs_ss.msr); /* record modem status */
  408.         if(rs_ss.flow == 1){
  409.           if(rs_ds.msr_cod & rs_ss.hdw_flw)
  410.             rs_ds.ier_msk = '\x0F'; /* enable xmit interrupts */
  411.           else
  412.             rs_ds.ier_msk = '\x0D'; /* disable xmit interrupts */
  413.           outportb(rs_ss.ier,rs_ds.ier_msk);
  414.           }
  415.         }
  416.       }while(!((_AL = inportb(rs_ss.iir)) & '\x01')); /* loop if int. pending */
  417.     }
  418.   else
  419.     rs_oldvec(); /* no interrupt pending on entry - call old isr */
  420.  
  421.  
  422.   enable();  /* enable interrupts */
  423.   outportb('\x20','\x20'); /* non-specific EOI to 8259 */
  424.  
  425. }
  426.  
  427. /* rs_initport: Initialize port, interrupt vector and interrupt mask (see
  428.    description with function prototype for details on arguments). */
  429. int rs_initport(char rs_port,long rs_baud,char rs_parity,char rs_bits,
  430.                 char rs_stop,unsigned rs_userinbufsiz, char *rs_userinbuf,
  431.                 unsigned rs_useroutbufsiz,char *rs_useroutbuf)
  432. {
  433.  
  434.   extern struct rs_statics rs_ss;
  435.   extern volatile struct rs_dynamics rs_ds;
  436.   extern int rs_portopen;
  437.   extern void interrupt (*rs_oldvec)(void);
  438.   void interrupt (*rs_intfnc)(void);
  439.   int rs_init[] = {0x6328,0x2029,0x2E43,0x4B20,0x7261,0x6863,0x7265,
  440.                    0x3120,0x3939,0x2033};
  441.   int rs_dll,rs_dlm,rs_portbase,rs_ret;
  442.   int far *rs_bda;
  443.   unsigned char rs_dvsrl,rs_dvsrh,rs_mask,rs_irq,rs_tmp1,rs_tmp2,rs_tmp3;
  444.  
  445.  
  446.   if(rs_portopen) /* if there's already a port open, close it */
  447.     rs_close();
  448.   rs_ss.oldmask = '\0';
  449.  
  450.   /* make sure buffer size is valid */
  451.   if((rs_userinbufsiz - 1) & rs_userinbufsiz)
  452.     return -1;
  453.   rs_ss.ibuf_siz = rs_userinbufsiz - 1;
  454.   if((rs_ss.in_buf = (unsigned char *)rs_userinbuf) == NULL)
  455.     return -1;
  456. #ifndef RS_POLLED_XMIT
  457.   if((rs_useroutbufsiz - 1) & rs_useroutbufsiz)
  458.     return -2;
  459.   rs_ss.obuf_siz = rs_useroutbufsiz - 1;
  460.   if((rs_ss.out_buf = (unsigned char *)rs_useroutbuf) == NULL)
  461.     return -2;
  462. #endif
  463.  
  464.   /* initialize buffer head and tail pointers */
  465.   rs_ds.in_head = rs_ds.in_tail = rs_ds.out_head = rs_ds.out_tail = 0;
  466.  
  467.   if(rs_init[1])
  468.     rs_bda = (int far*)MK_FP(0x40,0); /* get far pointer to BIOS data area */
  469.  
  470.   switch(rs_port){ /* find i/o port address, interrupt number & mask */
  471.     case '1':
  472.       rs_portbase = *rs_bda;
  473.       if(rs_portbase == 0)
  474.         rs_portbase = 0x3F8;
  475.       rs_ss.int_no = 0x0C;
  476.       rs_mask = '\xEF';
  477.       rs_irq = 4;
  478.       break;
  479.     case '2':
  480.       rs_portbase = *(rs_bda + 1);
  481.       if(rs_portbase == 0)
  482.         rs_portbase = 0x3FE;
  483.       rs_ss.int_no = 0x0B;
  484.       rs_mask = '\xF7';
  485.       rs_irq = 3;
  486.       break;
  487.     case '3':
  488.       rs_portbase = *(rs_bda + 2);
  489.       if(rs_portbase == 0)
  490.         rs_portbase = 0x3E8;
  491.       if(rs_portbase == 0x3220){ /* if it's a PS/2 */
  492.         rs_ss.int_no = 0x0B;
  493.         rs_mask = '\xF7';
  494.         rs_irq = 3;
  495.         }
  496.       else{
  497.         rs_ss.int_no = 0x0C;
  498.         rs_mask = '\xEF';
  499.         rs_irq = 4;
  500.         }
  501.       break;
  502.     case '4':
  503.       rs_portbase = *(rs_bda + 3);
  504.       if(rs_portbase == 0)
  505.         rs_portbase = 0x2E8;
  506.       if(rs_portbase == 0x3228){ /* if it's a PS/2 */
  507.         rs_ss.int_no = 0x0C;
  508.         rs_mask = '\xEF';
  509.         rs_irq = 4;
  510.         }
  511.       else{
  512.         rs_ss.int_no = 0x0B;
  513.         rs_mask = '\xF7';
  514.         rs_irq = 3;
  515.         }
  516.       break;
  517.     default:
  518.       return -3;
  519.     }
  520.  
  521.   switch(rs_parity){
  522.     case 'N':
  523.       rs_parity = 0;
  524.       break;
  525.     case 'E':
  526.       rs_parity = '\x18';
  527.       break;
  528.     case 'O':
  529.       rs_parity = '\x08';
  530.       break;
  531.     case 'S':
  532.       rs_parity = '\x38';
  533.       break;
  534.     case 'M':
  535.       rs_parity = '\x28';
  536.       break;
  537.     default:
  538.       return -4;
  539.     }
  540.  
  541.   if(rs_bits == '7')
  542.     rs_bits = 2;
  543.   else if(rs_bits == '8')
  544.     rs_bits = 3;
  545.   else
  546.     return -5;
  547.  
  548.   if(rs_stop == '1')
  549.     rs_stop = 0;
  550.   else if(rs_stop == '2')
  551.     rs_stop = 4;
  552.   else
  553.     return -6;
  554.  
  555.   /* 8250 (or 16x50) registers: */
  556.   /* out, bit 7 of LCR = 0, (Transmit Holding Register) */
  557.   rs_ss.thr = rs_portbase + 0;
  558.   /* in, bit 7 of LCR = 0, (Receive Buffer Register) */
  559.   rs_ss.rbr = rs_portbase + 0;
  560.   /* out, bit 7 of LCR = 1, (Divisor Latch LSB) */
  561.   rs_dll = rs_portbase + 0;
  562.   /* out, bit 7 of LCR = 1, (Divisor Latch MSB) */
  563.   rs_dlm = rs_portbase + 1;
  564.   /* out, bit 7 of LCR = 0, (Interrupt Enable Register)
  565.                         bit 0 = 1 data rcvd
  566.                         bit 1 = 1 transmit holding reg. empty
  567.                         bit 2 = 1 data reception error
  568.                         bit 3 = 1 change in modem status
  569.                         bit 4-7 unused */
  570.   rs_ss.ier = rs_portbase + 1;
  571.   /* in, (Interrupt ID register)
  572.                         bit  0  :  0 = interrupt pending
  573.                         bits 2-1: 00 = modem status change - read status
  574.                                   01 = transmit ready - output character or
  575.                                        read iir to clear
  576.                                   10 = data rcvd - read data
  577.                                   11 = break or error
  578.                         bits 7-6: 11 = 16550 in FIFO mode */
  579.   rs_ss.iir = rs_portbase + 2;
  580.   /* out, (FIFO control register - 16550)
  581.                         bit 0: 1 = FIFO enable
  582.                         bit 1: 1 = RCVR FIFO reset
  583.                         bit 2: 1 = XMIT FIFO reset
  584.                         bit 6 & 7: RCVR trigger level
  585.                         (00 = 1, 01 = 4, 10 = 8, 11 = 14) */
  586.   rs_ss.fcr = rs_portbase + 2;
  587.   /* out, (Line Control Register)
  588.                         bits 0-1: Character Length
  589.                                      00 = 5 bits
  590.                                      01 = 6 bits
  591.                                      10 = 7 bits
  592.                                      11 = 8 bits
  593.                         bit 2: Number of stop bits
  594.                                       0 = 1 (1.5 if character length 5)
  595.                                       1 = 2
  596.                         bit 3: Parity
  597.                                       0 = no parity
  598.                                       1 = parity generated
  599.                         bit 4: Parity type
  600.                                       0 = odd
  601.                                       1 = even
  602.                         bit 5: Stick Parity
  603.                                       0 = disabled
  604.                                       1 = always 1 if bit 3 = 1 & bit 4 = 0 or
  605.                                           always 0 if bit 3 = 1 & bit 4 = 1 or
  606.                                           no parity if bit 3 = 0
  607.                         bit 6: Set Break
  608.                                       0 = disabled
  609.                                       1 = output string of 0s
  610.                         bit 7: Enable write to baud divisor regs. if 1 */
  611.   rs_ss.lcr = rs_portbase + 3;
  612.   /* out, (Modem Control Register)
  613.                         bit 0:        1 = data terminal ready
  614.                         bit 1:        1 = request to send
  615.                         bit 2:        1 = aux. output 1
  616.                         bit 3:        1 = aux. output 2 - enables hdwr intrrpts.
  617.                         bit 4:        1 = UART loopback mode
  618.                         bit 5-7:      always 0 */
  619.   rs_ss.mcr = rs_portbase + 4;
  620.   /* in, (Line Status Register)
  621.                         bit 0:        1 = character received
  622.                         bit 1:        1 = rcvd data overrun
  623.                         bit 2:        1 = parity error
  624.                         bit 3:        1 = framing error
  625.                         bit 4:        1 = break detected
  626.                         bit 5:        1 = transmit holding reg. empty
  627.                         bit 6:        1 = transmitter empty
  628.                         bit 7:        1 = rcvr FIFO error (16550) */
  629.   rs_ss.lsr = rs_portbase + 5;
  630.   /* in, (Modem Status Register)
  631.                         bit 0:        1 = delta clear to send
  632.                         bit 1:        1 = delta data set ready
  633.                         bit 2:        1 = delta ring indicator
  634.                         bit 3:        1 = delta data carrier detect
  635.                         bit 4:        1 = clear to send
  636.                         bit 5:        1 = data set ready
  637.                         bit 6:        1 = ring indicator
  638.                         bit 7:        1 = data carrier detect */
  639.   rs_ss.msr = rs_portbase + 6;
  640.  
  641.   /* check for existence of UART */
  642.   outportb(rs_ss.fcr,'\0');         /* if 16550, make it a 16450 */
  643.   rs_tmp1 = inportb(rs_ss.mcr);     /* save mcr */
  644.   rs_tmp2 = inportb(rs_ss.ier);     /* save ier */
  645.   outportb(rs_ss.ier,'\0');         /* disable interrupts at UART */
  646.   inportb(rs_ss.rbr);               /* read rcv buffer register */
  647.   inportb(rs_ss.lsr);               /* read lsr */
  648.   inportb(rs_ss.msr);               /* read msr */
  649.   inportb(rs_ss.iir);               /* read iir */
  650.   if(inportb(rs_ss.iir) != '\x01')  /* read it again, should indicate... */
  651.     return 0;                       /* ...no interrupt pending */
  652.   outportb(rs_ss.lcr,'\0');         /* make sure out2 is 0 */
  653.   outportb(rs_ss.ier,'\x02');       /* enable thre interrupt indication */
  654.   goto rs_J1;                       /* give UART some time */
  655.   rs_J1:
  656.   rs_tmp3 = inportb(rs_ss.iir);     /* get iir */
  657.   outportb(rs_ss.ier,rs_tmp2);      /* restore original values */
  658.   outportb(rs_ss.mcr,rs_tmp1);
  659.   if(rs_tmp3 != '\x02')             /* should have seen thre interrupt... */
  660.     return 0;                       /* ...else port is unavailable */
  661.  
  662.   /* find out what kind of UART it is */
  663.   rs_ss.xmitfifo = 1; /* initialize for no FIFO */
  664.   outportb(rs_portbase + 7,'\x55');  /* try writing scratch register */
  665.   if(inportb(rs_portbase + 7) != '\x55')  /* and then reading it */
  666.     rs_ret = 1; /* if value written wasn't read it's an 8250B */
  667.   else{
  668.     /* check for presence of 16550, if 16550A,C,CF, enable FIFOs */
  669.     outportb(rs_ss.fcr,'\x41'); /* enable FIFO's with 4 byte RCVR trig. level */
  670.     rs_tmp1 = inportb(rs_ss.iir);
  671.     rs_tmp1 &= '\xC0';
  672.     if(rs_tmp1 == (unsigned char)'\xC0'){ /* 16550A,C,CF bits 6 & 7 are set */
  673.       rs_ret = 4;
  674.       rs_ss.xmitfifo = 16;   /* #of bytes to write to XMIT FIFO per interrupt */
  675.       }
  676.     else{                 /* otherwise, it's an 8250A, 16450 or 16550 */
  677.       outportb(rs_ss.fcr,'\x0');
  678.       if(rs_tmp1 == (unsigned char)'\x80') /* 16550 */
  679.         rs_ret = 3;
  680.       else                                 /* 8250A or 16450 */
  681.         rs_ret = 2;
  682.       }
  683.     }
  684.  
  685.   /* get the baud rate divisor values */
  686.   rs_dvsrh = 0;
  687.   switch(rs_baud){
  688.     case 110L:
  689.       rs_dvsrh = '\x04';
  690.       rs_dvsrl = '\x17';
  691.       break;
  692.     case 300L:
  693.       rs_dvsrh = '\x01';
  694.       rs_dvsrl = '\x80';
  695.       break;
  696.     case 600L:
  697.       rs_dvsrl = '\xC0';
  698.       break;
  699.     case 1200L:
  700.       rs_dvsrl = '\x60';
  701.       break;
  702.     case 2400L:
  703.       rs_dvsrl = '\x30';
  704.       break;
  705.     case 4800L:
  706.       rs_dvsrl = '\x18';
  707.       break;
  708.     case 9600L:
  709.       rs_dvsrl = '\x0C';
  710.       break;
  711.     case 19200L:
  712.       rs_dvsrl = '\x06';
  713.       break;
  714.     case 38400L:
  715.       rs_dvsrl = '\x03';
  716.       break;
  717.     case 57600L:
  718.       rs_dvsrl = '\x02';
  719.       break;
  720.     case 115200L:
  721.       rs_dvsrl = '\x01';
  722.       break;
  723.     default:
  724.       return -7;
  725.     }
  726.  
  727.   rs_oldvec = getvect(rs_ss.int_no); /* get the old interrupt vector */
  728.   setvect(rs_ss.int_no,rs_inthndlr); /* plug in the new one */
  729.  
  730.   outportb(rs_ss.ier,0);      /* disable UART interrupts */
  731.   outportb(rs_ss.lcr,'\x80'); /* enable baud rate divisor registers */
  732.   outportb(rs_dll,rs_dvsrl);  /* write divisor lo byte */
  733.   outportb(rs_dlm,rs_dvsrh);  /* write divisor hi byte */
  734.   outportb(rs_ss.lcr,(rs_parity | rs_bits | rs_stop)); /* characteristics */
  735.   /* enable interrupts at UART, do not change modem control lines */
  736.   outportb(rs_ss.mcr,(inportb(rs_ss.mcr) | '\x08')); /* set out2 */
  737.   inportb(rs_ss.iir); /* clear out any data...*/
  738.   inportb(rs_ss.lsr); /*...left in...*/
  739.   inportb(rs_ss.rbr); /*...UART's status...*/
  740.   inportb(rs_ss.msr); /*...registers */
  741.  
  742.   disable();
  743.   outportb(rs_ss.ier,'\x0D'); /* enable UART interrupts */
  744.   inportb(rs_ss.iir);
  745.   outportb(0x20,('\xC0' | (rs_irq - 1))); /* change 8259 interrupt priorities */
  746.   rs_ss.oldmask = inportb(0x21);   /* save old interrupt controller mask */
  747.   rs_mask &= rs_ss.oldmask;
  748.   outportb(0x21,rs_mask); /* interrupt now enabled */
  749.   rs_ds.msr_cod = inportb(rs_ss.msr) & '\xF0'; /* initialize modem status */
  750.   enable();
  751.  
  752.   rs_timer(0);             /* zero out tick counter */
  753.   rs_ss.flow = 0;          /* initialize flow control */
  754.   rs_ds.rcv_cnt = 0;       /* initialize receive count */
  755.   rs_ds.ier_msk = '\x0F';  /* insure that xmit interrupts stay enabled */
  756.   rs_ds.err_cod = '\x00';  /* initialize error flags */
  757.  
  758.   rs_portopen = 1;         /* set port open flag */
  759.   rs_ss.uart = rs_ret - 1; /* set UART type */
  760.   return rs_ret;
  761.  
  762. }
  763.  
  764. /* rs_close: Restore original 8259 interrupt controller mask value and
  765.    interrupt priorities.  Disable UART interrupts and restore original
  766.    interrupt vector. */
  767. void rs_close(void)
  768. {
  769.  
  770.   extern struct rs_statics rs_ss;
  771.   extern volatile struct rs_dynamics rs_ds;
  772.   extern int rs_portopen;
  773.   extern void interrupt (*rs_oldvec)(void);
  774.   unsigned rs_time,rs_tail;
  775.  
  776.   if(! rs_portopen) /* no port to close */
  777.     return;
  778.  
  779.   /* if buffer xmit in progress, wait til it's done */
  780.   if(rs_ds.ier_msk == '\x0F'){
  781.     rs_time = rs_timer(1);
  782.     rs_tail = rs_ds.out_tail;
  783.     while(rs_ds.out_head != rs_ds.out_tail)
  784.       /* make sure output is moving else time out (wait one char period) */
  785.       if(rs_timer(1) - rs_time > 4 && rs_tail == rs_ds.out_tail)
  786.         break;
  787.     }
  788.  
  789.   /* insure that tranmitter is empty before continuing */
  790.   rs_time = rs_timer(1);
  791.   while(! (inportb(rs_ss.lsr) & '\x40'))
  792.     if(rs_timer(1) - rs_time > 4)
  793.       break;
  794.  
  795.   if(rs_ss.oldmask){
  796.     disable();
  797.     outportb(0x21,rs_ss.oldmask);    /* restore old interrupt mask value */
  798.     outportb(0x20,'\xC7');           /* restore interrupt priorities */
  799.     enable();
  800.     }
  801.  
  802.   /* disable UART interrupts */
  803.   outportb(rs_ss.ier,0);
  804.   outportb(rs_ss.mcr,inportb(rs_ss.mcr) & '\xF7');
  805.  
  806.   /* restore old interrupt vector */
  807.   if(rs_oldvec != NULL)
  808.     setvect(rs_ss.int_no,rs_oldvec);
  809.   rs_oldvec = NULL;
  810.  
  811.   rs_portopen = 0; /* signal port closed */
  812.  
  813. }
  814.  
  815. /* rs_sndbyt: Output byte via output buffer.  If no space in output buffer,
  816.    wait til there is unless output is disabled via flow control, in which
  817.    case return -1.  If RS_POLLED_XMIT is defined, the byte is written to
  818.    the port when the transmit holding register becomes empy.  THRE interrupt
  819.    and output buffer are not used.  Return -1 if output disabled via flow
  820.    control. */
  821.  
  822. int rs_sndbyt(int rs_snd)
  823. {
  824.  
  825.   extern int rs_portopen;
  826.   extern volatile struct rs_dynamics rs_ds;
  827.   extern struct rs_statics rs_ss;
  828.  
  829.  
  830.   if(! rs_portopen) /* is a port open ? */
  831.     return -1;
  832.  
  833. #ifndef RS_POLLED_XMIT /* interrupt driven output */
  834.   while(((rs_ds.out_head + 1)  & rs_ss.obuf_siz) == rs_ds.out_tail){
  835.     /* make sure there's room in the buffer */
  836.     /* if xmit disabled via flow control, don't wait */
  837.     if(rs_ds.ier_msk == '\x0D')
  838.       return -1;
  839.     }
  840.   disable();
  841.   *(rs_ss.out_buf + rs_ds.out_head++) = (unsigned char)rs_snd;
  842.   rs_ds.out_head &= rs_ss.obuf_siz;
  843.   enable();
  844.   if(rs_ds.ier_msk != '\x0D'){
  845.     outportb(rs_ss.ier,'\x0D');
  846.     if(! rs_ss.uart)           /* if it's an 8250 or 8250B... */
  847.       while(! (inportb(rs_ss.lsr) & '\x20')) /* ...wait for THRE */
  848.         ;
  849.     outportb(rs_ss.ier,'\x0F'); /* generate an interrupt if needed */
  850.     }
  851. #else /* polled mode output */
  852.   if(rs_ds.ier_msk == '\x0D')
  853.     return -1;
  854.   while(! (inportb(rs_ss.lsr) & '\x20')) /* wait for THRE */
  855.     ;
  856.   outportb(rs_ss.thr,(unsigned char)rs_snd);
  857. #endif
  858.   return 0;
  859.  
  860. }
  861.  
  862.  
  863. /* rs_sndstr: Output rs_sndcnt chars from rs_str to output buffer.  If not
  864.    enough space in output buffer, wait til there is.  If output disabled
  865.    via flow control, return count of characters written to output buffer
  866.    if less than string length.  If rs_sndcnt is 0, output characters from
  867.    rs_str until nul character is reached.  If RS_POLLED_XMIT is defined,
  868.    string is written to port by polling the line status register for THRE
  869.    and the buffer is not used.  If output is disabled via flow control,
  870.    return count of characters sent */
  871.  
  872. int rs_sndstr(int rs_sndcnt, char *rs_str)
  873. {
  874.  
  875.   extern struct rs_statics rs_ss;
  876.   extern volatile struct rs_dynamics rs_ds;
  877.   int rs_x,rs_y;
  878.  
  879.   if(! rs_portopen) /* is a port open? */
  880.     return -1;
  881.  
  882.   if(rs_sndcnt) /* string length specified? */
  883.     rs_y = rs_sndcnt;
  884.   else
  885.     rs_y = 0x7FFF; /* max buffer length (`11/2) */
  886.  
  887. #ifndef RS_POLLED_XMIT /* interrupt driven transmit */
  888.   for(rs_x = 0;rs_x < rs_y;rs_x++){
  889.     /* if no string length specified, stop when nul is encountered */
  890.     if(! rs_sndcnt){
  891.       if(*(rs_str + rs_x) == '\0')
  892.         break;
  893.       }
  894.     while(((rs_ds.out_head + 1)  & rs_ss.obuf_siz) == rs_ds.out_tail){
  895.       /* if xmit disabled via flow control,don't wait */
  896.       if(rs_ds.ier_msk == '\x0D')
  897.         return rs_x;
  898.       else{ /* otherwise, may need to get xmit interrupts going (`11/2) */
  899.         outportb(rs_ss.ier,'\x0D');
  900.         if(! rs_ss.uart)           /* if it's an 8250 or 8250B... */
  901.           while(! (inportb(rs_ss.lsr) & '\x20'))  /* wait for THRE */
  902.             ;
  903.         outportb(rs_ss.ier,'\x0F'); /* kick transmit interrupt */
  904.         }
  905.       }
  906.     disable();
  907.     *(rs_ss.out_buf + rs_ds.out_head++) = (unsigned char)*(rs_str + rs_x);
  908.     rs_ds.out_head &= rs_ss.obuf_siz;
  909.     enable();
  910.     }
  911.   if(rs_ds.ier_msk != '\x0D'){
  912.     outportb(rs_ss.ier,'\x0D');
  913.     if(! rs_ss.uart)
  914.       while(! (inportb(rs_ss.lsr) & '\x20'))
  915.         ;
  916.     outportb(rs_ss.ier,'\x0F'); /* generate an interrupt if needed */
  917.     }
  918. #else /* polled transmit */
  919.   for(rs_x = 0;rs_x < rs_y;rs_x++){
  920.     /* if xmit disabled via flow control,don't wait */
  921.     if(rs_ds.ier_msk == '\x0D')
  922.       return rs_x;
  923.     /* if no string length specified, stop when nul is encountered */
  924.     if(! rs_sndcnt){
  925.       if(*(rs_str + rs_x) == '\0')
  926.         break;
  927.       }
  928.     while(! (inportb(rs_ss.lsr) & '\x20'))
  929.       ;
  930.     outportb(rs_ss.thr,(unsigned char)*(rs_str + rs_x));
  931.     }
  932. #endif
  933.   return 0;
  934.  
  935. }
  936.  
  937.  
  938. /* rs_outfre: Return amount of free space available in output buffer.
  939.    This function does not return a meaningful value if RS_POLLED_XMIT is
  940.    defined because transmission does not use the buffer */
  941. unsigned rs_outfre(void)
  942. {
  943.  
  944.   extern struct rs_statics rs_ss;
  945.   extern volatile struct rs_dynamics rs_ds;
  946.  
  947.   return(rs_ss.obuf_siz + 1 - ((rs_ds.out_head - rs_ds.out_tail) &
  948.                                                        rs_ss.obuf_siz));
  949.  
  950. }
  951.  
  952. /* rs_getbyt: Return next available character from input buffer - return
  953.    -1 if none are available */
  954. int rs_getbyt(void)
  955. {
  956.  
  957.   extern struct rs_statics rs_ss;
  958.   extern volatile struct rs_dynamics rs_ds;
  959.   extern int rs_portopen;
  960.   unsigned char rs_byt;
  961.  
  962.   if(! rs_portopen) /* is a port open? */
  963.     return -1;
  964.  
  965.   if(! rs_ds.rcv_cnt) /* char available ? */
  966.     return -1;
  967.   rs_byt = *(rs_ss.in_buf + rs_ds.in_tail++);
  968.   rs_ds.rcv_cnt--;
  969.   rs_ds.in_tail &= rs_ss.ibuf_siz;
  970.   return (int)rs_byt;
  971.  
  972. }
  973.  
  974. /* rs_getstr: Get specified number of bytes from port buffer and place in
  975.    user specified buffer.  Null terminate string.  If receive buffer
  976.    has fewer than the requested number of characters available, copy all
  977.    that are available.  Return number of bytes copied.  If rs_getcnt is 0,
  978.    copy characters until a nul is encountered (include it in getbuf) */
  979. int rs_getstr(int rs_getcnt,char *rs_getbuf)
  980. {
  981.  
  982.   extern struct rs_statics rs_ss;
  983.   extern int rs_portopen;
  984.   int rs_x = 0;
  985.   int rs_c,rs_y;
  986.  
  987.   if(! rs_portopen) /* is a port open? */
  988.     return -1;
  989.  
  990.   if(rs_getcnt) /* was number of characters specified? */
  991.     rs_y = rs_getcnt;
  992.   else
  993.     rs_y = rs_ss.ibuf_siz;
  994.  
  995.   while(rs_x < rs_y){
  996.     if((rs_c = rs_getbyt()) < 0)
  997.       break;
  998.     else
  999.       *(rs_getbuf + rs_x++) = (char)rs_c;
  1000.     if(! rs_getcnt){ /* if no length specified, end when nul is encountered */
  1001.       if(! rs_c)
  1002.         break;
  1003.       }
  1004.     }
  1005.  
  1006.   if(rs_getcnt) /* nul terminate if need be */
  1007.     *(rs_getbuf + rs_x) = '\0';
  1008.   return rs_x;
  1009.  
  1010. }
  1011.  
  1012. /* rs_inrcvd: Return number of received bytes waiting to be read from input
  1013.    buffer. */
  1014. unsigned rs_inrcvd(void)
  1015. {
  1016.  
  1017.   extern volatile struct rs_dynamics rs_ds;
  1018.   extern struct rs_statics rs_ss;
  1019.  
  1020.   if(rs_ds.rcv_cnt > rs_ss.ibuf_siz + 1){
  1021.     rs_ds.rcv_cnt = rs_ss.ibuf_siz + 2;
  1022.     return(rs_ss.ibuf_siz + 1);
  1023.     }
  1024.   else
  1025.     return rs_ds.rcv_cnt;
  1026.  
  1027. }
  1028.  
  1029. /* rs_error: Return last error detected as follows:
  1030.         bit 0: 1 = Buffer overrun
  1031.         bit 1: 1 = Receive data overrun
  1032.         bit 2: 1 = Parity error
  1033.         bit 3: 1 = Framing error
  1034.         bit 4: 1 = Break detected
  1035.         bit 7: 1 = Error in receive FIFO */
  1036. int rs_error(void)
  1037. {
  1038.  
  1039.   extern struct rs_statics rs_ss;
  1040.   extern volatile struct rs_dynamics rs_ds;
  1041.   int rs_errtmp;
  1042.  
  1043.   rs_errtmp = (int)(rs_ds.err_cod & 0x9E);
  1044.   if(rs_ds.rcv_cnt > (rs_ss.ibuf_siz + 1)){ /* receive buffer overflow ? */
  1045.     rs_errtmp |= 0x01;                      /*   set flag */
  1046.     rs_ds.rcv_cnt = rs_ss.ibuf_siz + 1;
  1047.     }
  1048.   rs_ds.err_cod = '\0';
  1049.   return rs_errtmp;
  1050.  
  1051. }
  1052.  
  1053. /* rs_modctrl: If rs_cmd = 0, return value of modem status register as of
  1054.    most recent change.  If rs_cmd = 1, switch line determined by parameter1
  1055.    on or off depending on whether parameter2 is 1 or 0.  If rs_cmd = 2,
  1056.    return contents of modem control register */
  1057. int rs_modctrl(int rs_cmd,...)
  1058. {
  1059.  
  1060.   extern struct rs_statics rs_ss;
  1061.   extern volatile struct rs_dynamics rs_ds;
  1062.   extern int rs_portopen;
  1063.   unsigned char rs_cntrl;
  1064.   int rs_tmp = 0;
  1065.   va_list rs_ap;
  1066.  
  1067.   va_start(rs_ap,rs_cmd);
  1068.  
  1069.   if(rs_portopen){
  1070.     if(rs_cmd == 2)
  1071.       rs_tmp = inportb(rs_ss.mcr);
  1072.     else if(rs_cmd == 1){ /*manipulate control line (modem control reg.) */
  1073.       rs_cntrl = (unsigned char)(va_arg(rs_ap,int));
  1074.       if(va_arg(rs_ap,int))
  1075.         rs_cntrl |= inportb(rs_ss.mcr);
  1076.       else{
  1077.         rs_cntrl ^= '\xFF';
  1078.         rs_cntrl &= inportb(rs_ss.mcr);
  1079.         }
  1080.       outportb(rs_ss.mcr,rs_cntrl);
  1081.       }
  1082.     else{ /* get modem status register */
  1083.       rs_tmp = (int)rs_ds.msr_cod;
  1084.       rs_ds.msr_cod &= '\xF0';
  1085.       }
  1086.     }
  1087.   else /* no port open */
  1088.     rs_tmp = -1;
  1089.  
  1090.   va_end(rs_ap);
  1091.  
  1092.   return rs_tmp;
  1093.  
  1094. }
  1095.  
  1096. /* send break */
  1097. int rs_break(void)
  1098. {
  1099.  
  1100.   extern struct rs_statics rs_ss;
  1101.   extern volatile struct rs_dynamics rs_ds;
  1102.   extern int rs_portopen;
  1103.   unsigned char rs_tmp;
  1104.   unsigned rs_time;
  1105.  
  1106.   if(! rs_portopen) /* is a port open? */
  1107.     return -1;
  1108.  
  1109.   rs_tmp = (char)inportb(rs_ss.lcr);
  1110.  
  1111.   while(rs_ds.out_tail != rs_ds.out_head)
  1112.     if(rs_ds.ier_msk == '\x0D')
  1113.       break;
  1114.  
  1115.   while(!((inportb(rs_ss.lsr)) & '\x20'))
  1116.     ;
  1117.  
  1118.   rs_tmp = inportb(rs_ss.lcr);
  1119.   rs_time = rs_timer(1);
  1120.   outportb(rs_ss.lcr,rs_tmp | '\x40');
  1121.   while(rs_timer(1) - rs_time < 4)
  1122.     ;
  1123.   outportb(rs_ss.lcr,rs_tmp);
  1124.  
  1125.   return 0;
  1126.  
  1127. }
  1128.  
  1129. /* clear input buffer */
  1130. void rs_clrin(void)
  1131. {
  1132.  
  1133.   extern struct rs_statics rs_ss;
  1134.   extern volatile struct rs_dynamics rs_ds;
  1135.  
  1136.   if(! rs_portopen) /* is a port open? */
  1137.     return;
  1138.  
  1139.   disable();
  1140.   rs_ds.in_tail = rs_ds.in_head;
  1141.   rs_ds.rcv_cnt = 0;
  1142.   if(rs_ss.xmitfifo == 16) /* if FIFOs enabled */
  1143.     outportb(rs_ss.fcr,'\x43'); /* clear RCVR FIFO */
  1144.   enable();
  1145.  
  1146. }
  1147.  
  1148. /* clear output buffer */
  1149. void rs_clrout(void)
  1150. {
  1151.  
  1152.   extern struct rs_statics rs_ss;
  1153.   extern volatile struct rs_dynamics rs_ds;
  1154.  
  1155.   if(! rs_portopen) /* is a port open? */
  1156.     return;
  1157.  
  1158.   disable();
  1159.   rs_ds.out_tail = rs_ds.out_head;
  1160.   if(rs_ss.xmitfifo == 16) /* if FIFOs enabled */
  1161.     outportb(rs_ss.fcr,'\x45'); /* clear XMIT FIFO */
  1162.   enable();
  1163.  
  1164. }
  1165.  
  1166. /* use BIOS keyboard buffer head and tail pointers to determine if a key
  1167.    has been pressed */
  1168. int rs_keyhit(void)
  1169. {
  1170.  
  1171.   volatile int far* rs_keytail;
  1172.   volatile int far* rs_keyhead;
  1173.  
  1174.   rs_keyhead = (int far*)MK_FP(0x40,0x1A);
  1175.   rs_keytail = rs_keyhead + 1;
  1176.  
  1177.   if(*rs_keytail == *rs_keyhead)
  1178.     return 0;
  1179.   else
  1180.     return 1;
  1181.  
  1182. }
  1183.  
  1184. /* use BIOS data area tick count to as 10/182 sec. resolution timer.  If
  1185.    rs_cmd is 0, clear counter and return count up to that point.  Id
  1186.    rs_cmd is non-zero, return tick count from the point which timer is
  1187.    last cleared. */
  1188. unsigned rs_timer(int rs_cmd)
  1189. {
  1190.  
  1191.   volatile unsigned long far* rs_biosticks;
  1192.   static long rs_startticks;
  1193.   unsigned rs_tmp;
  1194.  
  1195.   rs_biosticks = (unsigned long far*)MK_FP(0x40,0x6C);
  1196.  
  1197.   if(rs_cmd){
  1198.     if(*rs_biosticks >= rs_startticks)
  1199.       return((unsigned)(*rs_biosticks - rs_startticks));
  1200.     else
  1201.       return((unsigned)(*rs_biosticks + 1573040UL - rs_startticks));
  1202.     }
  1203.   else{
  1204.     if(*rs_biosticks >= rs_startticks)
  1205.       rs_tmp = (unsigned)(*rs_biosticks - rs_startticks);
  1206.     else
  1207.       rs_tmp = (unsigned)(*rs_biosticks + 1573040UL - rs_startticks);
  1208.     rs_startticks = *rs_biosticks;
  1209.     }
  1210.  
  1211.   return rs_tmp;
  1212.  
  1213. }
  1214.  
  1215. /* rs_setflow: rs_cmd = 0: Turn flow control off
  1216.                rs_cmd = 1: Set flow control to hardware - Parameter1
  1217.                            is hardware line to monitor.
  1218.                rs_cmd = 2: Set flow control to XON/XOFF - Parameter1
  1219.                            is character to use for XON, Parameter2
  1220.                            is character to use for XOFF.
  1221.                rs_cmd = 3: Return status of flow control - 0 = output
  1222.                            normal, 1 = output halted
  1223.                rs_cmd = 4: Insert control character in output stream.
  1224.                            Parameter1 is control character.
  1225.                rs_cmd = 5: Manipulate hardware line.  Parameter1 is bit
  1226.                            pattern corresponding to line to change.
  1227.                            If parameter2 is 0, line is turned off,
  1228.                            if 1, line is turned on*/
  1229. int rs_setflow(int rs_cmd,...)
  1230. {
  1231.  
  1232.   extern struct rs_statics rs_ss;
  1233.   extern volatile struct rs_dynamics rs_ds;
  1234.   extern int rs_portopen;
  1235.   int rs_ret = 0;
  1236.   unsigned char rs_cntrl;
  1237.   va_list rs_ap;
  1238.  
  1239.   va_start(rs_ap, rs_cmd);
  1240.  
  1241.   if(rs_portopen){
  1242.     switch(rs_cmd){
  1243.       case 0: /* turn flow control off */
  1244.         rs_ss.flow = rs_cmd;
  1245.         break;
  1246.       case 1: /* set flow control to hardware */
  1247.         rs_ss.flow = rs_cmd;
  1248.         rs_ss.hdw_flw = ((char)va_arg(rs_ap,int)) << 4;
  1249.         if((inportb(rs_ss.msr)) & rs_ss.hdw_flw)
  1250.           rs_ds.ier_msk = '\x0F';
  1251.         else
  1252.           rs_ds.ier_msk = '\x0D';
  1253.         break;
  1254.       case 2: /* set flow control to XON/XOFF */
  1255.         rs_ss.flow = rs_cmd;
  1256.         rs_ss.xon = (char)(va_arg(rs_ap,int));
  1257.         rs_ss.xoff = (char)(va_arg(rs_ap,int));
  1258.         break;
  1259.       case 3: /* return status of flow control */
  1260.         rs_ret = (rs_ds.ier_msk == '\x0D');
  1261.         break;
  1262.       case 4: /* insert control character in output stream */
  1263.         rs_cntrl = (char)(va_arg(rs_ap,int));
  1264. #ifndef RS_POLLED_XMIT
  1265.         outportb(rs_ss.ier,'\x0D');
  1266. #endif
  1267.         while(!(inportb(rs_ss.lsr) & '\x20'))
  1268.           ;
  1269.         outportb(rs_ss.thr,rs_cntrl);
  1270. #ifndef RS_POLLED_XMIT
  1271.         outportb(rs_ss.ier,rs_ds.ier_msk);
  1272. #endif
  1273.         break;
  1274.       }
  1275.     }
  1276.   else /* no port open */
  1277.     rs_ret = -1;
  1278.  
  1279.   va_end(rs_ap);
  1280.  
  1281.   return rs_ret;
  1282.  
  1283. }
  1284.